package com.monitor;

import com.monitor.model.MonitorConfig;
import com.monitor.model.ServerConfig;
import com.monitor.model.ServerStatus;
import com.monitor.service.factory.ReportGeneratorFactory;
import com.monitor.service.factory.ServerMonitorFactory;
import com.monitor.service.monitor.IServerMonitor;
import com.monitor.service.report.ReportGenerator;
import com.monitor.util.ConfigLoader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * 监控应用主类
 * 使用命令模式和工厂模式重构，提高代码的可扩展性和可读性
 */
public class MonitorApplication {
    private static final Logger logger = LoggerFactory.getLogger(MonitorApplication.class);
    
    /**
     * 应用入口
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        logger.info("服务器健康监控程序启动");
        
        // 创建监控控制器
        MonitorController controller = new MonitorController();
        
        // 运行监控任务
        controller.run();
        
        logger.info("监控完成，程序退出");
    }
    
    /**
     * 监控控制器
     * 命令模式：封装监控执行和报告生成的完整请求
     */
    static class MonitorController {
        private List<ServerConfig> serverConfigs;
        private MonitorConfig monitorConfig;
        private ExecutorService executor;
        
        /**
         * 初始化控制器
         */
        public MonitorController() {
            // 加载配置
            loadConfigurations();
        }
        
        /**
         * 运行监控任务
         */
        public void run() {
            if (!validateConfigurations()) {
                return;
            }
            
            // 创建线程池
            createThreadPool();
            
            try {
                // 执行监控
                List<ServerStatus> results = executeMonitoring();
                
                // 生成报告
                generateReports(results);
            } finally {
                // 关闭线程池
                shutdownThreadPool();
            }
        }
        
        /**
         * 加载配置
         */
        private void loadConfigurations() {
            serverConfigs = ConfigLoader.loadServers();
            monitorConfig = ConfigLoader.loadMonitorConfig();
        }
        
        /**
         * 验证配置是否有效
         * @return 配置是否有效
         */
        private boolean validateConfigurations() {
            if (serverConfigs.isEmpty()) {
                logger.error("没有有效的服务器配置，程序退出");
                return false;
            }
            
            if (monitorConfig == null) {
                logger.error("监控配置加载失败，程序退出");
                return false;
            }
            
            return true;
        }
        
        /**
         * 创建线程池
         */
        private void createThreadPool() {
            executor = Executors.newFixedThreadPool(monitorConfig.getThreadPoolSize());
        }
        
        /**
         * 执行监控任务
         * @return 监控结果列表
         */
        private List<ServerStatus> executeMonitoring() {
            List<Future<ServerStatus>> futures = new ArrayList<>();
            List<ServerStatus> results = new ArrayList<>();
            
            logger.info("开始监控 {} 台服务器", serverConfigs.size());
            
            // 为每台服务器创建监控任务
            for (ServerConfig serverConfig : serverConfigs) {
                Future<ServerStatus> future = executor.submit(() -> {
                    // 使用工厂创建监控器
                    IServerMonitor monitor = ServerMonitorFactory.createMonitor(serverConfig, monitorConfig);
                    return monitor.checkServerHealth();
                });
                futures.add(future);
            }
            
            // 收集监控结果
            for (Future<ServerStatus> future : futures) {
                try {
                    ServerStatus status = future.get();
                    results.add(status);
                    logger.info("服务器 {} [{}] 监控完成: {}", 
                        status.getServer().getName(), 
                        status.getServer().getHost(),
                        status.isOnline() ? "在线" : "离线");
                } catch (InterruptedException | ExecutionException e) {
                    logger.error("获取监控结果出错: {}", e.getMessage());
                }
            }
            
            return results;
        }
        
        /**
         * 生成监控报告
         * @param results 监控结果列表
         */
        private void generateReports(List<ServerStatus> results) {
            // 生成文本报告
            if (monitorConfig.getResultFilePath() != null && !monitorConfig.getResultFilePath().isEmpty()) {
                // 使用工厂创建文本格式报告生成器
                ReportGenerator textGenerator = ReportGeneratorFactory.createReportGenerator("text");
                boolean success = textGenerator.generateReport(results, monitorConfig.getResultFilePath());
                if (success) {
                    logger.info("文本报告生成成功: {}", monitorConfig.getResultFilePath());
                }
            }
            
            // 生成HTML报告
            if (monitorConfig.getHtmlReportPath() != null && !monitorConfig.getHtmlReportPath().isEmpty()) {
                // 使用工厂创建HTML格式报告生成器
                ReportGenerator htmlGenerator = ReportGeneratorFactory.createReportGenerator("html");
                boolean success = htmlGenerator.generateReport(results, monitorConfig.getHtmlReportPath());
                if (success) {
                    logger.info("HTML报告生成成功: {}", monitorConfig.getHtmlReportPath());
                }
            }
        }
        
        /**
         * 关闭线程池
         */
        private void shutdownThreadPool() {
            if (executor != null) {
                executor.shutdown();
                try {
                    // 等待最多30秒让任务完成
                    if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
                        // 如果超时仍有任务未完成，则强制关闭
                        executor.shutdownNow();
                    }
                } catch (InterruptedException e) {
                    executor.shutdownNow();
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
} 